// var http = require('http')
// var ejs = require('ejs');
// var MongoClient = require('mongodb').MongoClient;
// var fs = require('fs')
// var url = require('url')
// var template = require('art-template')
var express = require("express");
var tools = require("./Utilites/tools.js");
var User = require("./models/user");
var Topic = require("./models/topic");
var Comment = require("./models/comment");
var md5 = require("blueimp-md5");

const mongoose = require("mongoose");
// const { escapeRegExpChars } = require('ejs/lib/utils')
// var DBurl = 'mongodb://localhost/test';
var router = express.Router();
// 首页
router.get("/", function (req, res) {
    //设置响应头 设置允许跨域
    res.setHeader("Access-Control-Allow-Origin", "*");
    //允许自定义响应头 *表示所有类型的请求头都可以接受
    res.setHeader("Access-Control-Allow-Headers", "*");
    Topic.aggregate(
        [
            {
                $lookup: {
                    from: "users",
                    localField: "authorId",
                    foreignField: "_id",
                    as: "user",
                },
            },
        ],
        function (err, docs) {
            if (err) {
                console.log(err);
                return res.status(500).send("Server error.");
            }
            res.render("index", {
                user: req.session.user,
                topics: docs,
            });
        }
    );
});
// 登录页面
router.get("/login", function (req, res) {
    //设置响应头 设置允许跨域
    res.setHeader("Access-Control-Allow-Origin", "*");
    //允许自定义响应头 *表示所有类型的请求头都可以接受
    res.setHeader("Access-Control-Allow-Headers", "*");
    res.render("login.html");
});
// 登录页面数据
router.post("/login", function (req, res, next) {
    //设置响应头 设置允许跨域
    res.setHeader("Access-Control-Allow-Origin", "*");
    //允许自定义响应头 *表示所有类型的请求头都可以接受
    res.setHeader("Access-Control-Allow-Headers", "*");
    // 1. 获取表单数据
    // 2. 查询数据库用户名密码是否正确
    // 3. 发送响应数据
    var body = req.body;

    User.findOne(
        {
            email: body.email,
            password: md5(md5(body.password)),
        },
        function (err, user) {
            if (err) {
                return next(err);
            }

            // 如果邮箱和密码匹配，则 user 是查询到的用户对象，否则就是 null
            if (!user) {
                return res.status(200).json({
                    err_code: 1,
                    message: "Email or password is invalid.",
                });
            }

            // 用户存在，登陆成功，通过 Session 记录登陆状态
            // console.log("user--->", user);
            req.session.user = user;
            // localStorage.setItem("user", user);
            console.log("session", req.session.user);
            res.status(200).json({
                err_code: 0,
                message: "OK",
            });
        }
    );
});
// 注册页面
router.get("/register", function (req, res, next) {
    //设置响应头 设置允许跨域
    res.setHeader("Access-Control-Allow-Origin", "*");
    //允许自定义响应头 *表示所有类型的请求头都可以接受
    res.setHeader("Access-Control-Allow-Headers", "*");
    res.render("register.html");
});
// 注册页面数据
router.post("/register", function (req, res, next) {
    //设置响应头 设置允许跨域
    res.setHeader("Access-Control-Allow-Origin", "*");
    //允许自定义响应头 *表示所有类型的请求头都可以接受
    res.setHeader("Access-Control-Allow-Headers", "*");
    // 1. 获取表单提交的数据
    //    req.body
    // 2. 操作数据库
    //    判断改用户是否存在：查询邮箱
    //    如果已存在，不允许注册
    //    如果不存在，注册新建用户
    // 3. 发送响应
    var body = req.body;
    User.findOne(
        {
            $or: [
                {
                    email: body.email,
                },
                // {
                //     nickname: body.nickname
                // }
            ],
        },
        function (err, data) {
            if (err) {
                return next(err);
            }
            //如果查询到数据
            if (data) {
                // 邮箱或者昵称已存在
                return res.status(200).json({
                    err_code: 1,
                    message: "邮箱已存在!",
                });
            }

            // 对密码进行 md5 重复加密
            // body.password = md5(md5(body.password))
            body.password = md5(md5(body.password));

            new User(body).save(function (err, user) {
                if (err) {
                    return next(err);
                }

                // 注册成功，使用 Session 记录用户的登陆状态
                req.session.user = user;

                // Express 提供了一个响应方法：json
                // 该方法接收一个对象作为参数，它会自动帮你把对象转为字符串再发送给浏览器
                res.status(200).json({
                    err_code: 0,
                    message: "OK",
                });

                // 服务端重定向只针对同步请求才有效，异步请求无效
                // res.redirect('/')
            });
        }
    );
});
// 回到登录页
router.get("/logout", function (req, res) {
    //设置响应头 设置允许跨域
    res.setHeader("Access-Control-Allow-Origin", "*");
    //允许自定义响应头 *表示所有类型的请求头都可以接受
    res.setHeader("Access-Control-Allow-Headers", "*");
    // 清除登陆状态
    req.session.user = null;

    // 重定向到登录页
    res.redirect("/login");
});
// 发表页
router.get("/topic/new", function (req, res) {
    //设置响应头 设置允许跨域
    res.setHeader("Access-Control-Allow-Origin", "*");
    //允许自定义响应头 *表示所有类型的请求头都可以接受
    res.setHeader("Access-Control-Allow-Headers", "*");
    res.render("./topic/new.html", {
        user: req.session.user,
    });
});
// 发表页面数据
router.post("/topic/new", function (req, res) {
    //设置响应头 设置允许跨域
    res.setHeader("Access-Control-Allow-Origin", "*");
    //允许自定义响应头 *表示所有类型的请求头都可以接受
    res.setHeader("Access-Control-Allow-Headers", "*");
    new Topic(req.body).save(function (err) {
        if (err) {
            return res.status(500).send("Server error.");
        }
        res.redirect("/");
    });
});
// 查看文章页面
router.get("/topic/show", function (req, res) {
    //设置响应头 设置允许跨域
    res.setHeader("Access-Control-Allow-Origin", "*");
    //允许自定义响应头 *表示所有类型的请求头都可以接受
    res.setHeader("Access-Control-Allow-Headers", "*");
    //在客户端的列表页中处理链接问题（需要有 id 参数）
    // replace
    //    字符串模式
    //      简单，但是不支持全局和忽略大小写问题
    //    正则表达式模式
    //      强大，支持全局和忽略大小写
    // req.query.id.replace(/"/g, ''),
    var reg = new RegExp('"', "g");
    var activeId = req.query.id.replace(reg, "");
    console.log("activeId-->", activeId);
    Topic.aggregate(
        [
            {
                $lookup: {
                    from: "users",
                    localField: "authorId",
                    foreignField: "_id",
                    as: "user",
                },
            },
            {
                $match: { _id: mongoose.Types.ObjectId(activeId) },
            },
        ],
        function (err, docs) {
            if (err) {
                console.log(err);
                return res.status(500).send("查询文章失败");
            }
            // 获取指定评论
            Comment.aggregate(
                [
                    {
                        $lookup: {
                            from: "users",
                            localField: "userId",
                            foreignField: "_id",
                            as: "user",
                        },
                    },
                    {
                        $match: { activeId: mongoose.Types.ObjectId(activeId) },
                    },
                ],
                function (e, comments) {
                    if (e) {
                        console.log(err);
                        return res.status(500).send("查询评论失败");
                    }
                    console.log("comments-->", comments);
                    res.render("./topic/show.html", {
                        user: req.session.user,
                        topic: docs,
                        comments: comments,
                    });
                }
            );
            // Comment.find({ "id": activeId }, function(a, comments) {
            //     if (a) {
            //         console.log(err)
            //         return res.status(500).send('Server error.')
            //     }
            //     console.log('comments-->', comments);
            //     res.render('./topic/show.html', {
            //         user: req.session.user,
            //         topic: docs,
            //         comments: comments
            //     })
            // })
        }
    );
    // Topic.findById(req.query.id.replace(/"/g, ''), function(err, topic) {
    //     if (err) {
    //         console.log(err)
    //         return res.status(500).send('Server error.')
    //     }
    //     // 获取指定评论
    //     Comment.find({ "id": uid }, function(a, comments) {
    //         if (a) {
    //             console.log(err)
    //             return res.status(500).send('Server error.')
    //         }
    //         res.render('./topic/show.html', {
    //             user: req.session.user,
    //             topic: topic,
    //             comments: comments
    //         })
    //     })

    // })
});
//评论数据
router.post("/topic/show", function (req, res) {
    //设置响应头 设置允许跨域
    res.setHeader("Access-Control-Allow-Origin", "*");
    //允许自定义响应头 *表示所有类型的请求头都可以接受
    res.setHeader("Access-Control-Allow-Headers", "*");

    req.body.activeId = req.body.activeId.replace(/"/g, "");
    req.body.authorId = req.body.authorId.replace(/"/g, "");
    console.log("req.body-->", req.body);
    new Comment(req.body).save(function (err) {
        if (err) {
            console.log(err);
            return res.status(500).send("回复失败");
        }
        res.status(200).json({
            err_code: 0,
            message: "OK",
        });
    });
});
// 设置页
router.get("/settings/profile", function (req, res) {
    //设置响应头 设置允许跨域
    res.setHeader("Access-Control-Allow-Origin", "*");
    //允许自定义响应头 *表示所有类型的请求头都可以接受
    res.setHeader("Access-Control-Allow-Headers", "*");
    res.render("./settings/profile.html", {
        user: req.session.user,
    });
});
// 账号设置页
router.get("/settings/admin", function (req, res) {
    //设置响应头 设置允许跨域
    res.setHeader("Access-Control-Allow-Origin", "*");
    //允许自定义响应头 *表示所有类型的请求头都可以接受
    res.setHeader("Access-Control-Allow-Headers", "*");
    res.render("./settings/admin.html", {
        user: req.session.user,
    });
});
//处理账号密码修改数据
router.post("/settings/admin", function (req, res) {
    //设置响应头 设置允许跨域
    res.setHeader("Access-Control-Allow-Origin", "*");
    //允许自定义响应头 *表示所有类型的请求头都可以接受
    res.setHeader("Access-Control-Allow-Headers", "*");
    var id = req.body.id.replace(/"/g, "");
    // 密码加密
    req.body.password = md5(md5(req.body.password));
    User.findByIdAndUpdate(id, req.body, function (err) {
        if (err) {
            return res.status(500).send("Server error.");
        }
        res.redirect("/login");
    });
});
//处理账号昵称头像修改数据
router.post(
    "/settings/admin/2",
    tools.multer().single("avatar"),
    function (req, res) {
        console.log("文件：", req.file);
        req.body["avatar"] = req.file?.path;
        //设置响应头 设置允许跨域
        res.setHeader("Access-Control-Allow-Origin", "*");
        //允许自定义响应头 *表示所有类型的请求头都可以接受
        res.setHeader("Access-Control-Allow-Headers", "*");
        var id = req.body.id.replace(/"/g, "");

        User.findByIdAndUpdate(id, req.body, function (err, data) {
            if (err) {
                return res.status(500).send("Server error.");
            }

            res.redirect("/login");
        });
    }
);
// 删除账号
router.get("/user/delete", function (req, res) {
    //设置响应头 设置允许跨域
    res.setHeader("Access-Control-Allow-Origin", "*");
    //允许自定义响应头 *表示所有类型的请求头都可以接受
    res.setHeader("Access-Control-Allow-Headers", "*");
    var id = req.query.id.replace(/"/g, "");
    Comment.deleteMany({ userId: id }, function (err) {
        if (err) {
            return res.status(500).send("删除该用户评论失败");
        }
    });
    Comment.deleteMany({ authorId: id }, function (err) {
        if (err) {
            return res.status(500).send("删除该用户评论失败");
        }
    });
    Topic.deleteMany({ authorId: id }, function (err) {
        if (err) {
            return res.status(500).send("删除该用户评论失败");
        }
    });
    User.findByIdAndRemove(id, function (err) {
        if (err) {
            return res.status(500).send("删除该用户失败");
        }
        res.redirect("/login");
    });
});
//个人页面
router.get("/settings/content", function (req, res) {
    //设置响应头 设置允许跨域
    res.setHeader("Access-Control-Allow-Origin", "*");
    //允许自定义响应头 *表示所有类型的请求头都可以接受
    res.setHeader("Access-Control-Allow-Headers", "*");

    var reg = new RegExp('"', "g");
    var uid = req.query.id.replace(reg, "");
    /**
     * 聚合查询
     * 此处为将users表（对应的是数据库里的表名）的_id与Topic的authorId相等的数据添加到Topic数据的user字段下
     * match为筛选条件，此处为查对应作者的Topic
     */
    Topic.aggregate(
        [
            {
                $lookup: {
                    from: "users",
                    localField: "authorId",
                    foreignField: "_id",
                    as: "user",
                },
            },
            {
                $match: { authorId: mongoose.Types.ObjectId(uid) },
            },
        ],
        function (err, docs) {
            if (err) {
                console.log(err);
                return res.status(500).send("Server error.");
            }
            // console.log(docs);
            res.render("./settings/content.html", {
                user: req.session.user,
                topics: docs,
            });
        }
    );
    // Topic.find({ "id": uid }, function(a, topics) {
    //     if (a) {
    //         console.log(err)
    //         return res.status(500).send('Server error.')
    //     }
    //     res.render('./settings/content.html', {
    //         user: req.session.user,
    //         topics: topics

    //     })
    // })
});
module.exports = router;
